home *** CD-ROM | disk | FTP | other *** search
/ Turnbull China Bikeride / Turnbull China Bikeride - Disc 1.iso / DEMON / RISCOS2 / TCP_131S.ARC / c / window < prev   
Text File  |  1994-03-07  |  8KB  |  432 lines
  1. #define EXPRO 0
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include <stdarg.h>
  7. #include <signal.h>
  8.  
  9. #include "akbd.h"
  10. #if EXPRO
  11. #include "exprofle.h"
  12. #endif
  13. #include "wimpt.h"
  14. #include "res.h"
  15. #include "resspr.h"
  16. #include "template.h"
  17. #include "dbox.h"
  18. #include "flex.h"
  19. #include "heap.h"
  20. #include "kernel.h"
  21. #include "event.h"
  22. #include "visdelay.h"
  23. #include "baricon.h"
  24. #include "menu.h"
  25. #include "saveas.h"
  26. #include "werr.h"
  27. #include "wimp.h"
  28. #include "win.h"
  29. #include "alarm.h"
  30. #include "global.h"
  31. #include "config.h"
  32. #include "cmdparse.h"
  33. #include "misc.h"
  34. #include "driver.h"
  35. #include "Terminal.h"
  36.  
  37. #define Icon_Menu_Info  1
  38. #define Icon_Menu_Quit  2
  39.  
  40. Terminal *MWin = NULL;
  41. Terminal *TWin = NULL;
  42.  
  43. static BOOL Trace_Window_Open = FALSE;
  44.  
  45. static menu Icon_Menu;
  46.  
  47. static int  doscale(int, char **);
  48. static int  dostatus(int, char **);
  49. static int  doterminal(int, char **);
  50. static void Icon_MenuProc(void *, char *);
  51. static void Icon_Click(wimp_i);
  52. static void Alarm_Handler(int, void *);
  53. static void Signal_Proc(int);
  54.  
  55. int term_type = -1;
  56.  
  57. int32 wimp_ver;
  58. static char term_name[12];
  59.  
  60. static int (*terminal_driver)(int,...);
  61. extern int (*pipe_load(char *))(int,...);
  62.  
  63. extern char version[];
  64. extern char arc_vs[];
  65. extern char compile_date[];
  66.  
  67. extern char startup[];
  68.  
  69. extern BOOL scale;
  70.  
  71. static struct cmds wincmds[] = {
  72.   "scale",        doscale,        0, NULLCHAR, NULLCHAR,
  73.   "status",       dostatus,       0, NULLCHAR, NULLCHAR,
  74.   "terminal",     doterminal,     0, NULLCHAR, NULLCHAR,
  75.   NULLCHAR,
  76. };
  77.  
  78. int dowin(int argc, char **argv)
  79. {
  80.   return subcmd(wincmds, argc, argv);
  81. }
  82.  
  83. int doterminal(int argc, char **argv)
  84. {
  85.   int ports, loop;
  86.  
  87.   if (argc == 1)
  88.   {
  89.     cwprintf(NULL, "Using %s terminal", term_type < 0 ? "internal" : "external");
  90.     if (term_type != -1)
  91.       cwprintf(NULL, " with %s driver\r\n", term_name);
  92.     else
  93.       cwprintf(NULL, "\r\n");
  94.   }
  95.   else
  96.   {
  97.     if (argc > 1 && strnlcmp(argv[1], "external", MIN(strlen(argv[1]), 8)) == 0)
  98.     {
  99.       terminal_driver = pipe_load(argv[2]);
  100.       ports = ((int *) terminal_driver)[49];
  101.       for (loop = 0; loop < ports / 0x1000000; loop++)
  102.         (terminal_driver)(DRIVER_INITIALISE, loop);
  103.       term_type = 0;
  104.       strcpy(term_name, argv[2]);
  105.       Window_Close(MWin);
  106.       Window_Close(TWin);
  107.     }
  108.     if (strnlcmp(argv[1], "internal", MIN(strlen(argv[1]), 8)) == 0)
  109.     {
  110.       wimp_wstate state;
  111.  
  112.       wimp_get_wind_state(MWin->Window_Handle, &state);
  113.       wimp_open_wind(&state.o);
  114.       term_type = -1;
  115.     }
  116.     cwprintf(NULL, "KA9Q Internet Protocol Package, v%s\r\n", version);
  117.     cwprintf(NULL, "Original program copyright 1988 by Phil Karn, KA9Q\r\n");
  118.     cwprintf(NULL, "NET/ROM support copyright 1989 by Dan Frank, W9NK\r\n") ;
  119.     cwprintf(NULL, "Original Acorn Archimedes port by Jonathan Naylor, G4KLX\r\n");
  120.     cwprintf(NULL, "Further work by Anthony Frost, Thomas Aeby and Andrew Draper\r\n");
  121.     cwprintf(NULL, "\r\nThis is Arc version %s, compiled %s\r\n\r\n", arc_vs, __DATE__);
  122.   }
  123.   return(FALSE);
  124. }
  125.  
  126. static int doscale(int argc, char **argv)
  127. {
  128.   if (argc == 1)
  129.   {
  130.     cwprintf(NULL, "scaling is %s\r\n", (scale) ? "on" : "off");
  131.   }
  132.   else
  133.   {
  134.     if (stricmp(argv[1], "on") == 0)
  135.     {
  136.       scale = TRUE;
  137.     }
  138.     else
  139.     {
  140.       scale = FALSE;
  141.     }
  142.   }
  143.   return 0;
  144. }
  145.  
  146. static int dostatus(int argc, char **argv)
  147. {
  148.   argc = argc;
  149.   argv = argv;
  150.  
  151.   cwprintf(NULL, "trace window: status:%s\r\n", (Trace_Window_Open) ? "open" : "closed");
  152.  
  153.   return(0);
  154. }
  155.  
  156. int main(int argc, char **argv)
  157. {
  158. #if EXPRO
  159.   exprofle_init("<TCPIP$Dir>.profile");
  160. #endif
  161.   wimp_ver = wimpt_init("TCP/IP");
  162.   res_init("TCPIP");
  163.   flex_init();
  164.   _kernel_register_slotextend(flex_budge);
  165.   resspr_init();
  166.   template_init();
  167.   dbox_init();
  168.   visdelay_init();
  169.   alarm_init();
  170.  
  171.   argc = argc;
  172.   argv = argv;
  173.  
  174.   signal(SIGABRT, Signal_Proc);
  175.   signal(SIGFPE,  Signal_Proc);
  176.   signal(SIGILL,  Signal_Proc);
  177.   signal(SIGINT,  Signal_Proc);
  178.   signal(SIGSEGV, Signal_Proc);
  179.   signal(SIGTERM, Signal_Proc);
  180.   signal(SIGSTAK, Signal_Proc);
  181.   signal(8, Signal_Proc);
  182.   signal(9, Signal_Proc);
  183.  
  184.   visdelay_begin();
  185.  
  186.   if ((Icon_Menu = menu_new("TCP/IP", ">Info,Quit")) == NULL)
  187.   {
  188.     visdelay_end();
  189.     return(1);
  190.   }
  191.  
  192.   baricon("!tcpip", (int)resspr_area(), Icon_Click);
  193.  
  194.   if (!event_attachmenu(win_ICONBAR, Icon_Menu, Icon_MenuProc, 0))
  195.   {
  196.     visdelay_end();
  197.     return(1);
  198.   }
  199.  
  200.   wimp_save_fp_state_on_poll();
  201.  
  202.   if (TWin = Window_Open(NULL, "Trace Window", term_DONT_OPEN | term_DONT_DESTROY | term_NO_INPUT), TWin == NULL)
  203.   {
  204.     visdelay_end();
  205.     return(1);
  206.   }
  207.   Window_Close(TWin);
  208.   
  209.   if (MWin = Window_Open(NULL, "TCPIP Command Window", term_CARET | term_DONT_DESTROY), MWin == NULL)
  210.   {
  211.     visdelay_end();
  212.     return(1);
  213.   }
  214.  
  215.   net_init();
  216.  
  217.   visdelay_end();
  218.  
  219.   alarm_set(alarm_timenow() + 1, Alarm_Handler, 0);
  220.  
  221.   while (TRUE)
  222.     event_process();
  223.  
  224.   return(0);
  225. }
  226.  
  227. static void Icon_MenuProc(void *Handle, char *Hit)
  228. {
  229.   char buffer[50];
  230.   dbox d;
  231.  
  232.   Handle = Handle;
  233.  
  234.   switch (Hit[0])
  235.   {
  236.   case Icon_Menu_Info:
  237.     if ((d = dbox_new("progInfo")) == NULL)
  238.       return;
  239.     sprintf(buffer, "%s %s", arc_vs, compile_date);
  240.     dbox_setfield(d, 4, buffer);
  241.     dbox_show(d);
  242.     dbox_fillin(d);
  243.     dbox_dispose(&d);
  244.     break;
  245.  
  246.   case Icon_Menu_Quit:
  247.     net_exit();
  248.  
  249.   default:
  250.     break;
  251.   }
  252. }
  253.  
  254. static void Icon_Click(wimp_i Icon)
  255. {
  256.   wimp_wstate state;
  257.  
  258.   Icon = Icon;
  259.  
  260.   if (term_type == -1)
  261.   {
  262.     wimp_get_wind_state(MWin->Window_Handle, &state);
  263.     wimp_open_wind(&state.o);
  264.   }
  265. }
  266.  
  267. static void Alarm_Handler(int Time, void *Handle)
  268. {
  269.   int c;
  270.  
  271.   Handle = Handle;
  272.   Time   = Time;
  273.  
  274.   if (term_type != -1)
  275.   {
  276.     while (c = (terminal_driver)(DRIVER_GETBYTE, 0x00), c >= 0)
  277.       net_keyboard(c);
  278.   }
  279.   net_poll();
  280.  
  281.   alarm_set(alarm_timenow() + 1, Alarm_Handler, 0);
  282. }
  283.  
  284. void cwputs(Terminal *port, char *s)
  285. {
  286.   if (term_type == -1)
  287.   {
  288.     Window_Write((port ? port : MWin), s, strlen(s));
  289.   }
  290.   else
  291.   {
  292.     while(*s)
  293.       (terminal_driver)(DRIVER_PUTBYTE, 0x00, *s++);
  294.   }
  295. }
  296.  
  297. int cwprintf(Terminal *port, char *fmt, ...)
  298. {
  299.   va_list args;
  300.   static char Buffer[1000];
  301.   int cnt;
  302.  
  303.   va_start(args, fmt);
  304.   cnt = vsprintf(Buffer, fmt, args);
  305.   va_end(args);
  306.  
  307.   cwputs(port, Buffer);
  308.  
  309.   return(cnt);
  310. }
  311.  
  312. int cwputchar(Terminal *port, int c)
  313. {
  314.   if (term_type == -1)
  315.   {
  316.     if (port)
  317.       Window_Write(port, (char *) &c, 1);
  318.     else
  319.       Window_Write(MWin, (char *) &c, 1);
  320.   }
  321.   else
  322.   {
  323.     (terminal_driver)(DRIVER_PUTBYTE, 0x00, c);
  324.   }
  325.   return(c);
  326. }
  327.  
  328. int cwtitle(Terminal *port, char *fmt, ...)
  329. {
  330.   va_list args;
  331.   static char Buffer[100];
  332.   int cnt;
  333.  
  334.   va_start(args, fmt);
  335.   cnt = vsprintf(Buffer, fmt, args);
  336.   va_end(args);
  337.  
  338.   if (port)
  339.     win_settitle(port->Window_Handle, Buffer);
  340.   else
  341.     win_settitle(MWin->Window_Handle, Buffer);
  342.  
  343.   return(cnt);
  344. }
  345.  
  346. void twopen(void)
  347. {
  348.   if (!Trace_Window_Open)
  349.   {
  350.     wimp_wstate state;
  351.     
  352.     wimp_get_wind_state(TWin->Window_Handle, &state);
  353.     wimp_open_wind(&state.o);
  354.     Trace_Window_Open = TRUE;
  355.   }
  356. }
  357.  
  358. void twclose(void)
  359. {
  360.   Window_Close(TWin);
  361.     Trace_Window_Open = FALSE;
  362. }
  363.  
  364. void twputs(char *s)
  365. {
  366.   Window_Write(TWin, s, strlen(s));
  367. }
  368.  
  369. int twprintf(char *fmt, ...)
  370. {
  371.   va_list args;
  372.   static char Buffer[1000];
  373.   int cnt;
  374.  
  375.   va_start(args, fmt);
  376.   cnt = vsprintf(Buffer, fmt, args);
  377.   va_end(args);
  378.  
  379.   twputs(Buffer);
  380.  
  381.   return(cnt);
  382. }
  383.  
  384. int twputchar(int c)
  385. {
  386.   Window_Write(TWin, (char *) &c, 1);
  387.   return(c);
  388. }
  389.  
  390. void panic(char *fmt, ...)
  391. {
  392.   static char Buffer[500];
  393.   va_list args;
  394.  
  395.   va_start(args, fmt);
  396.   vsprintf(Buffer, fmt, args);
  397.   va_end(args);
  398.  
  399.   werr(TRUE, Buffer);
  400. }
  401.  
  402. static void Signal_Proc(int Signal)
  403. {
  404.   switch (Signal)
  405.   {
  406.   case SIGABRT:
  407.     werr(TRUE, "Abort signal received");
  408.     break;
  409.   case SIGFPE:
  410.     werr(TRUE, "Arithmetic exception"); 
  411.     break;
  412.   case SIGILL:
  413.     werr(TRUE, "Illegal instruction");
  414.     break;
  415.   case SIGINT:
  416.     werr(TRUE, "Attention requested from user"); 
  417.     break;
  418.   case SIGSEGV:
  419.     werr(TRUE, "Bad memory access");
  420.     break;
  421.   case SIGTERM:
  422.     werr(TRUE, "Termination request"); 
  423.     break;
  424.   case SIGSTAK:
  425.     werr(TRUE, "Stack overflow");
  426.     break;
  427.   default:
  428.     werr(TRUE, "Signal number %d", Signal);
  429.     break;
  430.   }
  431. }
  432.